//package cn.lh.util;
//
//import javax.crypto.Cipher;
//import javax.crypto.SecretKeyFactory;
//import javax.crypto.spec.PBEKeySpec;
//import java.io.ByteArrayOutputStream;
//import java.nio.charset.StandardCharsets;
//import java.security.Key;
//import java.security.KeyFactory;
//import java.security.KeyPair;
//import java.security.KeyPairGenerator;
//import java.security.NoSuchAlgorithmException;
//import java.security.PrivateKey;
//import java.security.PublicKey;
//import java.security.SecureRandom;
//import java.security.Signature;
//import java.security.interfaces.RSAPrivateKey;
//import java.security.interfaces.RSAPublicKey;
//import java.security.spec.InvalidKeySpecException;
//import java.security.spec.PKCS8EncodedKeySpec;
//import java.security.spec.X509EncodedKeySpec;
//import java.util.Base64;
//import java.util.HashMap;
//import java.util.Map;
//
//
///**
// * <p>
// * RSA公钥/私钥/签名工具包
// * </p>
// * <p>
// * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
// * </p>
// * <p>
// * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
// * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
// * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
// * </p>
// *
// * @author IceWee
// * @version 1.0
// * @date 2012-4-26
// */
//public class RSAUtils {
//
//
//    /**
//     * 加密算法RSA
//     */
//    public static final String KEY_ALGORITHM = "RSA";
//
//
//    /**
//     * 签名算法
//     */
//    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
//
//
//    /**
//     * 获取公钥的key
//     */
//    private static final String PUBLIC_KEY = "RSAPublicKey";
//
//
//    /**
//     * 获取私钥的key
//     */
//    private static final String PRIVATE_KEY = "RSAPrivateKey";
//
//
//    /**
//     * RSA最大加密明文大小
//     */
//    private static final int MAX_ENCRYPT_BLOCK = 64;
//
//
//    /**
//     * RSA最大解密密文大小
//     */
//    private static final int MAX_DECRYPT_BLOCK = 128;
//    /**
//     * 加密算法RSA/ECB/PKCS1Padding和填充模式
//     */
//    private static final String ALGORITHM = "PBKDF2WithHmacSHA256";
//
//    /**
//     * 迭代次数
//     */
//    private static final int ITERATIONS = 65536;
//
//    /**
//     * 密钥长度
//     */
//    private static final int KEY_LENGTH = 256;
//    /**
//     * 盐长度 (字节长度)
//     */
//    private static final int SALT_LENGTH = 16;
//
//    /**
//     * <p>
//     * 生成密钥对(公钥和私钥)
//     * </p>
//     *
//     * @return
//     * @throws Exception
//     */
//    public static Map<String, Object> genKeyPair() {
//        KeyPairGenerator keyPairGen = null;
//        try {
//            keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
//
//            keyPairGen.initialize(1024);
//            KeyPair keyPair = keyPairGen.generateKeyPair();
//            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//            Map<String, Object> keyMap = new HashMap<String, Object>(2);
//            keyMap.put(PUBLIC_KEY, publicKey);
//            keyMap.put(PRIVATE_KEY, privateKey);
//            return keyMap;
//        } catch (NoSuchAlgorithmException e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * <p>
//     * 获取私钥
//     * </p>
//     *
//     * @param keyMap 密钥对
//     * @return
//     * @throws Exception
//     */
//    public static String getPrivateKey(Map<String, Object> keyMap) {
//        Key key = (Key) keyMap.get(PRIVATE_KEY);
//        return Base64Util.encodeToStr(key.getEncoded());
//    }
//
//
//    /**
//     * <p>
//     * 获取公钥
//     * </p>
//     *
//     * @param keyMap 密钥对
//     * @return
//     * @throws Exception
//     */
//    public static String getPublicKey(Map<String, Object> keyMap) {
//        Key key = (Key) keyMap.get(PUBLIC_KEY);
//        return Base64Util.encodeToStr(key.getEncoded());
//    }
//
//
//    /**
//     * <p>
//     * 用私钥对信息生成数字签名
//     * </p>
//     *
//     * @param data       已加密数据
//     * @param privateKey 私钥(BASE64编码)
//     * @return
//     * @throws Exception
//     */
//    public static String sign(byte[] data, String privateKey) throws Exception {
//        byte[] keyBytes = Base64Util.decode(privateKey);
//        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
//        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
//        signature.initSign(privateK);
//        signature.update(data);
//        return Base64Util.encodeToStr(signature.sign());
//    }
//
//
//    /**
//     * <p>
//     * 校验数字签名
//     * </p>
//     *
//     * @param data      已加密数据
//     * @param publicKey 公钥(BASE64编码)
//     * @param sign      数字签名
//     * @return
//     * @throws Exception
//     */
//    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
//        byte[] keyBytes = Base64Util.decode(publicKey);
//        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        PublicKey publicK = keyFactory.generatePublic(keySpec);
//        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
//        signature.initVerify(publicK);
//        signature.update(data);
//        return signature.verify(Base64Util.decode(sign));
//    }
//
//    /**
//     * <P>
//     * 私钥解密
//     * </p>
//     *
//     * @param encryptedData 已加密数据
//     * @param privateKey    私钥(BASE64编码)
//     * @return
//     * @throws Exception
//     */
//    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
//        byte[] keyBytes = Base64Util.decode(privateKey);
//        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
//        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
//        cipher.init(Cipher.DECRYPT_MODE, privateK);
//        int inputLen = encryptedData.length;
//        ByteArrayOutputStream out = new ByteArrayOutputStream();
//        int offSet = 0;
//        byte[] cache;
//        int i = 0;
//        // 对数据分段解密
//        while (inputLen - offSet > 0) {
//            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
//                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
//            } else {
//                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
//            }
//            out.write(cache, 0, cache.length);
//            i++;
//            offSet = i * MAX_DECRYPT_BLOCK;
//        }
//        byte[] decryptedData = out.toByteArray();
//        out.close();
//        return decryptedData;
//    }
//
//
//    /**
//     * <p>
//     * 公钥解密
//     * </p>
//     *
//     * @param encryptedData 已加密数据
//     * @param publicKey     公钥(BASE64编码)
//     * @return
//     * @throws Exception
//     */
//    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
//        byte[] keyBytes = Base64Util.decode(publicKey);
//        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        Key publicK = keyFactory.generatePublic(x509KeySpec);
//        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
//        cipher.init(Cipher.DECRYPT_MODE, publicK);
//        int inputLen = encryptedData.length;
//        ByteArrayOutputStream out = new ByteArrayOutputStream();
//        int offSet = 0;
//        byte[] cache;
//        int i = 0;
//        // 对数据分段解密
//        while (inputLen - offSet > 0) {
//            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
//                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
//            } else {
//                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
//            }
//            out.write(cache, 0, cache.length);
//            i++;
//            offSet = i * MAX_DECRYPT_BLOCK;
//        }
//        byte[] decryptedData = out.toByteArray();
//        out.close();
//        return decryptedData;
//    }
//
//
//    /**
//     * <p>
//     * 公钥加密
//     * </p>
//     *
//     * @param data      源数据
//     * @param publicKey 公钥(BASE64编码)
//     * @return
//     * @throws Exception
//     */
//    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
//        byte[] keyBytes = Base64Util.decode(publicKey);
//        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        Key publicK = keyFactory.generatePublic(x509KeySpec);
//        // 对数据加密
//        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
//        cipher.init(Cipher.ENCRYPT_MODE, publicK);
//        int inputLen = data.length;
//        ByteArrayOutputStream out = new ByteArrayOutputStream();
//        int offSet = 0;
//        byte[] cache;
//        int i = 0;
//        // 对数据分段加密
//        while (inputLen - offSet > 0) {
//            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
//                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
//            } else {
//                cache = cipher.doFinal(data, offSet, inputLen - offSet);
//            }
//            out.write(cache, 0, cache.length);
//            i++;
//            offSet = i * MAX_ENCRYPT_BLOCK;
//        }
//        byte[] encryptedData = out.toByteArray();
//        out.close();
//        return encryptedData;
//    }
//
//    /**
//     * <p>
//     * 私钥加密
//     * </p>
//     *
//     * @param data       源数据
//     * @param privateKey 私钥(BASE64编码)
//     * @return
//     * @throws Exception
//     */
//    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
//        byte[] keyBytes = Base64Util.decode(privateKey);
//        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
//        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
//        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
//        cipher.init(Cipher.ENCRYPT_MODE, privateK);
//        int inputLen = data.length;
//        ByteArrayOutputStream out = new ByteArrayOutputStream();
//        int offSet = 0;
//        byte[] cache;
//        int i = 0;
//        // 对数据分段加密
//        while (inputLen - offSet > 0) {
//            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
//                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
//            } else {
//                cache = cipher.doFinal(data, offSet, inputLen - offSet);
//            }
//            out.write(cache, 0, cache.length);
//            i++;
//            offSet = i * MAX_ENCRYPT_BLOCK;
//        }
//        byte[] encryptedData = out.toByteArray();
//        out.close();
//        return encryptedData;
//    }
//
//
//    /**
//     * java端公钥加密
//     */
//    public static String encryptedDataOnJava(String data, String publicKey) {
//        try {
//            data = Base64Util.encodeToStr(encryptByPublicKey(data.getBytes(), publicKey));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return data;
//    }
//
//    /**
//     * java端私钥解密
//     */
//    public static String decryptDataOnJava(String data, String privateKey) {
//        String temp = "";
//        try {
//            byte[] rs = Base64Util.decode(data);
//            // 解密 以utf-8的方式生成字符串
//            temp = new String(RSAUtils.decryptByPrivateKey(rs, privateKey), StandardCharsets.UTF_8);
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return temp;
//    }
//
//    public static void main(String[] args) {
//        try {
//            Map<String, Object> keyMap = RSAUtils.genKeyPair();
//            String publicKey = RSAUtils.getPublicKey(keyMap);
//            String privateKey = RSAUtils.getPrivateKey(keyMap);
//            System.out.println("publicKey = " + publicKey);
//            System.out.println("privateKey = " + privateKey);
//            System.out.println("=============================");
//            String s = encryptedDataOnJava("123456", publicKey);
//            System.out.println("java端公钥加密  " + s);
//            String s21 = decryptDataOnJava(s, privateKey);
//            System.out.println("java端私钥解密 = " + s21);
//
//            //byte[] bytes = generateSalt();
//
//            //System.out.println("生成的盐 = " + bytes);
//            String s1 = "9be08179ba82f8e2068928c2494b577c";
//            System.out.println("16制字符 = " + s1.length());
//            byte[] bytes1 = hexToBytes(s1);
//            //System.out.println("bytesToHex(bytes) = " + Arrays.equals(bytes, bytes1));
//            String ss = hashPassword("123456", bytes1);
//            System.out.println("生成的哈希值 = " + ss.equals("zDuIyDjB1Qwi54j2j2fyPsmkvAjUNw/rT/92pAG6fNg="));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * =============================== 密码加盐 =======================
//     */
//    /**
//     * 生成随机盐
//     *
//     * @return
//     * @throws NoSuchAlgorithmException
//     */
//    public static byte[] generateSalt() {
//        try {   // 使用 SecureRandom 来生成高质量的随机数
//            SecureRandom sr  = SecureRandom.getInstanceStrong();
//            byte[] salt = new byte[SALT_LENGTH];
//            sr.nextBytes(salt);
//            return salt;
//        } catch (NoSuchAlgorithmException e) {
//            throw new RuntimeException(e);
//        }
//
//    }
//
//    /**
//     * 将字节数组转换为十六进制字符串
//     *
//     * @param bytes
//     * @return
//     */
//    public static String bytesToHex(byte[] bytes) {
//        StringBuilder sb = new StringBuilder();
//        for (byte b : bytes) {
//            sb.append(String.format("%02x", b));
//        }
//        return sb.toString();
//    }
//
//    /**
//     * 将十六进制字符串转换为字节数组
//     *
//     * @param hex
//     * @return byte[]
//     */
//    public static byte[] hexToBytes(String hex) {
//        int len = hex.length();
//        byte[] data = new byte[len / 2];
//        for (int i = 0; i < len; i += 2) {
//            data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
//                    + Character.digit(hex.charAt(i + 1), 16));
//        }
//        return data;
//    }
//
//    /**
//     * ================================ 密码加密 ================================
//     */
//
//
//    /**
//     * 根据盐和密码生成加密密码（哈希值）
//     *
//     * @param password 密码
//     * @param salt     盐
//     * @return 哈希值（Base64编码）
//     * @throws NoSuchAlgorithmException
//     * @throws InvalidKeySpecException
//     */
//    public static String hashPassword(String password, byte[] salt) {
//        try {
//            // 创建PBEKeySpec对象
//            PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
//            // 创建SecretKeyFactory对象
//            SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);
//
//            // 生成密钥
//            byte[] hash = factory.generateSecret(spec).getEncoded();
//            // 使用Base64编码
//            return Base64.getEncoder().encodeToString(hash);
//        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 校验密码是否匹配
//     * @param dbHashPassword     数据库中存储的密码
//     * @param inputPassword     用户输入的密码
//     * @param dbSalt     数据库中存储的盐
//     * @return  true 匹配成功 false 匹配失败
//     */
//    public static boolean hashPasswordIsMatch(String dbHashPassword, String inputPassword, String dbSalt) {
//        byte[] byteSalts = hexToBytes(dbSalt);
//        String newHashedPassword = hashPassword(inputPassword, byteSalts);
//        return dbHashPassword.equals(newHashedPassword);
//    }
//
//}
